//package com.yupi.yupicturebackend.controller;
//
//import cn.hutool.core.util.RandomUtil;
//import cn.hutool.core.util.StrUtil;
//import cn.hutool.json.JSONUtil;
//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
//import com.github.benmanes.caffeine.cache.Cache;
//import com.github.benmanes.caffeine.cache.Caffeine;
//import com.yupi.yupicturebackend.annotation.AuthCheck;
import com.yupi.yupicturebackend.annotation.DataValidation;
import com.yupi.yupicturebackend.annotation.PerformanceMonitor;
//import com.yupi.yupicturebackend.api.aliyunai.AliYunAiApi;
//import com.yupi.yupicturebackend.api.aliyunai.model.CreateOutPaintingTaskResponse;
//import com.yupi.yupicturebackend.api.aliyunai.model.GetOutPaintingTaskResponse;
//import com.yupi.yupicturebackend.api.imagesearch.ImageSearchApiFacade;
//import com.yupi.yupicturebackend.api.imagesearch.model.ImageSearchResult;
//import com.yupi.yupicturebackend.common.BaseResponse;
//import com.yupi.yupicturebackend.common.DeleteRequest;
//import com.yupi.yupicturebackend.common.ResultUtils;
//import com.yupi.yupicturebackend.constant.UserConstant;
//import com.yupi.yupicturebackend.exception.BusinessException;
//import com.yupi.yupicturebackend.exception.ErrorCode;
//import com.yupi.yupicturebackend.exception.ThrowUtils;
//import com.yupi.yupicturebackend.manager.auth.SpaceUserAuthManager;
//import com.yupi.yupicturebackend.manager.auth.StpKit;
//import com.yupi.yupicturebackend.manager.auth.annotation.SaSpaceCheckPermission;
//import com.yupi.yupicturebackend.manager.auth.model.SpaceUserPermissionConstant;
//import com.yupi.yupicturebackend.model.dto.picture.*;
//import com.yupi.yupicturebackend.model.entity.Picture;
//import com.yupi.yupicturebackend.model.entity.Space;
//import com.yupi.yupicturebackend.model.entity.User;
//import com.yupi.yupicturebackend.model.enums.PictureReviewStatusEnum;
//import com.yupi.yupicturebackend.model.vo.PictureTagCategory;
//import com.yupi.yupicturebackend.model.vo.PictureVO;
//import com.yupi.yupicturebackend.service.PictureService;
//import com.yupi.yupicturebackend.service.SpaceService;
//import com.yupi.yupicturebackend.service.UserService;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.BeanUtils;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.data.redis.core.ValueOperations;
//import org.springframework.util.DigestUtils;
//import org.springframework.web.bind.annotation.*;
//import org.springframework.web.multipart.MultipartFile;
//
//import javax.annotation.Resource;
//import javax.servlet.http.HttpServletRequest;
//import java.time.Duration;
//import java.util.*;
//import java.util.concurrent.TimeUnit;
//import java.util.stream.Collectors;
//import java.util.stream.Stream;
//
///**
// * 图片控制器 - 改良版本
// * 使用Stream API优化代码，提高可读性和性能
// *
// * @author 程序员鱼皮 <a href="https://www.codefather.cn">编程导航原创项目</a>
// * @version 2.0 - 改良版本
// */
//@Slf4j
//@RestController
//@RequestMapping("/picture/v2")
//public class PictureControllerImproved {
//
//    @Resource
//    private UserService userService;
//
//    @Resource
//    private PictureService pictureService;
//
//    @Resource
//    private SpaceService spaceService;
//
//    @Resource
//    private StringRedisTemplate stringRedisTemplate;
//
//    @Resource
//    private AliYunAiApi aliYunAiApi;
//
//    @Resource
//    private SpaceUserAuthManager spaceUserAuthManager;
//
//    /**
//     * 本地缓存 - 使用更优雅的配置
//     */
//    private final Cache<String, String> LOCAL_CACHE = Caffeine.newBuilder()
//            .initialCapacity(1024)
//            .maximumSize(10_000L)
//            .expireAfterWrite(Duration.ofMinutes(5))
//            .recordStats() // 启用统计信息
//            .build();
//
//    /**
//     * 预定义的标签和分类列表 - 使用Stream优化
//     */
//    private static final List<String> DEFAULT_TAGS = Stream.of(
//            "热门", "搞笑", "生活", "高清", "艺术",
//            "校园", "背景", "简历", "创意", "科技"
//    ).collect(Collectors.toList());
//
//    private static final List<String> DEFAULT_CATEGORIES = Stream.of(
//            "模板", "电商", "表情包", "素材", "海报", "插画"
//    ).collect(Collectors.toList());
//
//    /**
//     * 业务常量定义
//     */
//    private static final long MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
//    private static final int MAX_BATCH_DELETE_SIZE = 100;
//    private static final int MAX_BATCH_REVIEW_SIZE = 50;
//    private static final int MAX_SEARCH_RESULT_SIZE = 20;
//    private static final int MAX_COLOR_SEARCH_SIZE = 50;
//
//    /**
//     * 上传图片（可重新上传）- 改良版本
//     *
//     * @param multipartFile 上传的文件
//     * @param pictureUploadRequest 上传请求参数
//     * @param request HTTP请求
//     * @return 上传结果
//     */
//    @PostMapping("/upload")
//    @SaSpaceCheckPermission(value = SpaceUserPermissionConstant.PICTURE_UPLOAD)
//    public BaseResponse<PictureVO> uploadPicture(
//            @RequestPart("file") MultipartFile multipartFile,
//            PictureUploadRequest pictureUploadRequest,
//            HttpServletRequest request) {
//
//        // 使用Optional优化空值处理
//        User loginUser = Optional.ofNullable(userService.getLoginUser(request))
//                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_LOGIN_ERROR));
//
//        // 参数校验 - 使用Stream优化
//        validateUploadRequest(multipartFile, pictureUploadRequest);
//
//        PictureVO pictureVO = pictureService.uploadPicture(multipartFile, pictureUploadRequest, loginUser);
//
//        // 记录上传日志
//        log.info("用户 {} 成功上传图片: {}", loginUser.getId(), pictureVO.getName());
//
//        return ResultUtils.success(pictureVO);
//    }
//
//    /**
//     * 通过 URL 上传图片（可重新上传）- 改良版本
//     */
//    @PostMapping("/upload/url")
//    @SaSpaceCheckPermission(value = SpaceUserPermissionConstant.PICTURE_UPLOAD)
//    public BaseResponse<PictureVO> uploadPictureByUrl(
//            @RequestBody PictureUploadRequest pictureUploadRequest,
//            HttpServletRequest request) {
//
//        User loginUser = Optional.ofNullable(userService.getLoginUser(request))
//                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_LOGIN_ERROR));
//
//        String fileUrl = Optional.ofNullable(pictureUploadRequest.getFileUrl())
//                .filter(StrUtil::isNotBlank)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "文件URL不能为空"));
//
//        PictureVO pictureVO = pictureService.uploadPicture(fileUrl, pictureUploadRequest, loginUser);
//
//        log.info("用户 {} 通过URL成功上传图片: {}", loginUser.getId(), fileUrl);
//
//        return ResultUtils.success(pictureVO);
//    }
//
//    /**
//     * 删除图片 - 改良版本
//     */
//    @PostMapping("/delete")
//    @SaSpaceCheckPermission(value = SpaceUserPermissionConstant.PICTURE_DELETE)
//    public BaseResponse<Boolean> deletePicture(@RequestBody DeleteRequest deleteRequest,
//                                             HttpServletRequest request) {
//
//        // 使用Optional和Stream优化参数校验
//        Long pictureId = Optional.ofNullable(deleteRequest)
//                .map(DeleteRequest::getId)
//                .filter(id -> id > 0)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "图片ID无效"));
//
//        User loginUser = userService.getLoginUser(request);
//        pictureService.deletePicture(pictureId, loginUser);
//
//        log.info("用户 {} 删除图片: {}", loginUser.getId(), pictureId);
//
//        return ResultUtils.success(true);
//    }
//
//    /**
//     * 批量删除图片 - 新增功能，使用Stream优化
//     */
//    @PostMapping("/delete/batch")
//    @SaSpaceCheckPermission(value = SpaceUserPermissionConstant.PICTURE_DELETE)
//    public BaseResponse<Integer> deletePicturesBatch(@RequestBody List<Long> pictureIds,
//                                                   HttpServletRequest request) {
//
//        // 使用Stream过滤和校验
//        List<Long> validIds = Optional.ofNullable(pictureIds)
//                .orElse(Collections.emptyList())
//                .stream()
//                .filter(Objects::nonNull)
//                .filter(id -> id > 0)
//                .distinct()
//                .collect(Collectors.toList());
//
//        ThrowUtils.throwIf(validIds.isEmpty(), ErrorCode.PARAMS_ERROR, "没有有效的图片ID");
//        ThrowUtils.throwIf(validIds.size() > MAX_BATCH_DELETE_SIZE, ErrorCode.PARAMS_ERROR, "批量删除数量不能超过" + MAX_BATCH_DELETE_SIZE);
//
//        User loginUser = userService.getLoginUser(request);
//
//        // 使用Stream并行处理批量删除
//        int deletedCount = validIds.parallelStream()
//                .mapToInt(pictureId -> {
//                    try {
//                        pictureService.deletePicture(pictureId, loginUser);
//                        return 1;
//                    } catch (BusinessException e) {
//                        log.warn("删除图片失败: {}, 业务错误: {}", pictureId, e.getMessage());
//                        return 0;
//                    } catch (Exception e) {
//                        log.error("删除图片异常: {}, 系统错误: {}", pictureId, e.getMessage(), e);
//                        return 0;
//                    }
//                })
//                .sum();
//
//        log.info("用户 {} 批量删除图片，成功删除 {} 张", loginUser.getId(), deletedCount);
//
//        return ResultUtils.success(deletedCount);
//    }
//
//    /**
//     * 更新图片（仅管理员可用）- 改良版本
//     */
//    @PostMapping("/update")
//    @AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
//    public BaseResponse<Boolean> updatePicture(@RequestBody PictureUpdateRequest pictureUpdateRequest,
//                                             HttpServletRequest request) {
//
//        // 使用Optional优化参数校验
//        Long pictureId = Optional.ofNullable(pictureUpdateRequest)
//                .map(PictureUpdateRequest::getId)
//                .filter(id -> id > 0)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "图片ID无效"));
//
//        // 转换实体类
//        Picture picture = new Picture();
//        BeanUtils.copyProperties(pictureUpdateRequest, picture);
//
//        // 使用Stream优化标签处理
//        Optional.ofNullable(pictureUpdateRequest.getTags())
//                .filter(tags -> !tags.isEmpty())
//                .map(JSONUtil::toJsonStr)
//                .ifPresent(picture::setTags);
//
//        // 数据校验
//        pictureService.validPicture(picture);
//
//        // 检查图片是否存在
//        Picture oldPicture = Optional.ofNullable(pictureService.getById(pictureId))
//                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND_ERROR, "图片不存在"));
//
//        // 补充审核参数
//        User loginUser = userService.getLoginUser(request);
//        pictureService.fillReviewParams(oldPicture, loginUser);
//
//        // 更新数据库
//        boolean result = pictureService.updateById(picture);
//        ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "更新失败");
//
//        log.info("管理员 {} 更新图片: {}", loginUser.getId(), pictureId);
//
//        return ResultUtils.success(true);
//    }
//
//    /**
//     * 根据 id 获取图片（仅管理员可用）- 改良版本
//     */
//    @GetMapping("/get")
//    @AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
//    public BaseResponse<Picture> getPictureById(long id, HttpServletRequest request) {
//
//        ThrowUtils.throwIf(id <= 0, ErrorCode.PARAMS_ERROR, "图片ID无效");
//
//        Picture picture = Optional.ofNullable(pictureService.getById(id))
//                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND_ERROR, "图片不存在"));
//
//        return ResultUtils.success(picture);
//    }
//
//    /**
//     * 根据 id 获取图片（封装类）- 改良版本
//     */
//    @GetMapping("/get/vo")
//    public BaseResponse<PictureVO> getPictureVOById(long id, HttpServletRequest request) {
//
//        ThrowUtils.throwIf(id <= 0, ErrorCode.PARAMS_ERROR, "图片ID无效");
//
//        Picture picture = Optional.ofNullable(pictureService.getById(id))
//                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND_ERROR, "图片不存在"));
//
//        // 空间权限校验 - 使用Optional优化
//        Space space = Optional.ofNullable(picture.getSpaceId())
//                .map(spaceId -> {
//                    boolean hasPermission = StpKit.SPACE.hasPermission(SpaceUserPermissionConstant.PICTURE_VIEW);
//                    ThrowUtils.throwIf(!hasPermission, ErrorCode.NO_AUTH_ERROR);
//
//                    return Optional.ofNullable(spaceService.getById(spaceId))
//                            .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND_ERROR, "空间不存在"));
//                })
//                .orElse(null);
//
//        // 获取权限列表
//        User loginUser = userService.getLoginUser(request);
//        List<String> permissionList = spaceUserAuthManager.getPermissionList(space, loginUser);
//
//        PictureVO pictureVO = pictureService.getPictureVO(picture, request);
//        pictureVO.setPermissionList(permissionList);
//
//        return ResultUtils.success(pictureVO);
//    }
//
//    /**
//     * 参数校验辅助方法 - 使用Stream优化
//     */
//    private void validateUploadRequest(MultipartFile multipartFile, PictureUploadRequest request) {
//        // 文件校验
//        Optional.ofNullable(multipartFile)
//                .filter(file -> !file.isEmpty())
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "上传文件不能为空"));
//
//        // 文件大小校验
//        ThrowUtils.throwIf(multipartFile.getSize() > MAX_FILE_SIZE,
//                ErrorCode.PARAMS_ERROR, "文件大小不能超过10MB");
//
//        // 文件类型校验 - 使用Stream优化
//        String filename = multipartFile.getOriginalFilename();
//        List<String> allowedExtensions = Arrays.asList("jpg", "jpeg", "png", "gif", "webp");
//
//        boolean isValidExtension = Optional.ofNullable(filename)
//                .map(name -> name.toLowerCase())
//                .filter(name -> name.contains("."))
//                .map(name -> name.substring(name.lastIndexOf(".") + 1))
//                .map(allowedExtensions::contains)
//                .orElse(false);
//
//        ThrowUtils.throwIf(!isValidExtension, ErrorCode.PARAMS_ERROR, "不支持的文件类型");
//    }
//
//    /**
//     * 分页获取图片列表（仅管理员可用）- 改良版本
//     */
//    @PostMapping("/list/page")
//    @AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
//    public BaseResponse<Page<Picture>> listPictureByPage(@RequestBody PictureQueryRequest pictureQueryRequest) {
//
//        // 使用Stream优化分页参数校验
//        long current = Optional.ofNullable(pictureQueryRequest)
//                .map(PictureQueryRequest::getCurrent)
//                .filter(c -> c > 0)
//                .orElse(1);
//
//        long size = Optional.ofNullable(pictureQueryRequest)
//                .map(PictureQueryRequest::getPageSize)
//                .filter(s -> s > 0 && s <= 50)
//                .orElse(10);
//
//        // 查询数据库
//        Page<Picture> picturePage = pictureService.page(
//                new Page<>(current, size),
//                pictureService.getQueryWrapper(pictureQueryRequest)
//        );
//
//        return ResultUtils.success(picturePage);
//    }
//
//    /**
//     * 分页获取图片列表（封装类）- 改良版本，使用Stream优化
//     */
//    @PostMapping("/list/page/vo")
//    public BaseResponse<Page<PictureVO>> listPictureVOByPage(@RequestBody PictureQueryRequest pictureQueryRequest,
//                                                           HttpServletRequest request) {
//
//        // 使用Stream优化参数处理
//        long current = Optional.ofNullable(pictureQueryRequest)
//                .map(PictureQueryRequest::getCurrent)
//                .filter(c -> c > 0)
//                .orElse(1);
//
//        long size = Optional.ofNullable(pictureQueryRequest)
//                .map(PictureQueryRequest::getPageSize)
//                .filter(s -> s > 0 && s <= 20)
//                .orElse(10);
//
//        // 空间权限校验 - 使用Optional优化
//        Optional.ofNullable(pictureQueryRequest)
//                .map(PictureQueryRequest::getSpaceId)
//                .ifPresentOrElse(
//                    spaceId -> {
//                        boolean hasPermission = StpKit.SPACE.hasPermission(SpaceUserPermissionConstant.PICTURE_VIEW);
//                        ThrowUtils.throwIf(!hasPermission, ErrorCode.NO_AUTH_ERROR);
//                    },
//                    () -> {
//                        // 公开图库 - 只显示审核通过的图片
//                        if (pictureQueryRequest != null) {
//                            pictureQueryRequest.setReviewStatus(PictureReviewStatusEnum.PASS.getValue());
//                            pictureQueryRequest.setNullSpaceId(true);
//                        }
//                    }
//                );
//
//        // 查询数据库
//        Page<Picture> picturePage = pictureService.page(
//                new Page<>(current, size),
//                pictureService.getQueryWrapper(pictureQueryRequest)
//        );
//
//        return ResultUtils.success(pictureService.getPictureVOPage(picturePage, request));
//    }
//
//    /**
//     * 获取图片标签和分类 - 改良版本，使用Stream优化
//     */
//    @GetMapping("/tag_category")
//    public BaseResponse<PictureTagCategory> listPictureTagCategory() {
//
//        // 创建标签分类对象
//        PictureTagCategory pictureTagCategory = new PictureTagCategory();
//        pictureTagCategory.setTagList(DEFAULT_TAGS);
//        pictureTagCategory.setCategoryList(DEFAULT_CATEGORIES);
//
//        return ResultUtils.success(pictureTagCategory);
//    }
//
//    /**
//     * 审核图片 - 改良版本
//     */
//    @PostMapping("/review")
//    @AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
//    public BaseResponse<Boolean> doPictureReview(@RequestBody PictureReviewRequest pictureReviewRequest,
//                                               HttpServletRequest request) {
//
//        // 使用Optional优化参数校验
//        Optional.ofNullable(pictureReviewRequest)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "审核请求不能为空"));
//
//        User loginUser = userService.getLoginUser(request);
//        pictureService.doPictureReview(pictureReviewRequest, loginUser);
//
//        log.info("管理员 {} 审核图片: {}, 状态: {}",
//                loginUser.getId(),
//                pictureReviewRequest.getId(),
//                pictureReviewRequest.getReviewStatus());
//
//        return ResultUtils.success(true);
//    }
//
//    /**
//     * 批量审核图片 - 新增功能，使用Stream优化
//     */
//    @PostMapping("/review/batch")
//    @AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
//    public BaseResponse<Integer> doPictureReviewBatch(@RequestBody List<PictureReviewRequest> reviewRequests,
//                                                    HttpServletRequest request) {
//
//        // 使用Stream过滤和校验
//        List<PictureReviewRequest> validRequests = Optional.ofNullable(reviewRequests)
//                .orElse(Collections.emptyList())
//                .stream()
//                .filter(Objects::nonNull)
//                .filter(req -> req.getId() != null && req.getId() > 0)
//                .filter(req -> req.getReviewStatus() != null)
//                .collect(Collectors.toList());
//
//        ThrowUtils.throwIf(validRequests.isEmpty(), ErrorCode.PARAMS_ERROR, "没有有效的审核请求");
//        ThrowUtils.throwIf(validRequests.size() > MAX_BATCH_REVIEW_SIZE, ErrorCode.PARAMS_ERROR, "批量审核数量不能超过" + MAX_BATCH_REVIEW_SIZE);
//
//        User loginUser = userService.getLoginUser(request);
//
//        // 使用Stream并行处理批量审核
//        int reviewedCount = validRequests.parallelStream()
//                .mapToInt(reviewRequest -> {
//                    try {
//                        pictureService.doPictureReview(reviewRequest, loginUser);
//                        return 1;
//                    } catch (BusinessException e) {
//                        log.warn("审核图片失败: {}, 业务错误: {}", reviewRequest.getId(), e.getMessage());
//                        return 0;
//                    } catch (Exception e) {
//                        log.error("审核图片异常: {}, 系统错误: {}", reviewRequest.getId(), e.getMessage(), e);
//                        return 0;
//                    }
//                })
//                .sum();
//
//        log.info("管理员 {} 批量审核图片，成功审核 {} 张", loginUser.getId(), reviewedCount);
//
//        return ResultUtils.success(reviewedCount);
//    }
//
//    /**
//     * 批量抓取并创建图片 - 改良版本
//     */
//    @PostMapping("/upload/batch")
//    @AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
//    public BaseResponse<Integer> uploadPictureByBatch(@RequestBody PictureUploadByBatchRequest pictureUploadByBatchRequest,
//                                                    HttpServletRequest request) {
//
//        // 使用Optional优化参数校验
//        Optional.ofNullable(pictureUploadByBatchRequest)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "批量上传请求不能为空"));
//
//        User loginUser = userService.getLoginUser(request);
//        int uploadCount = pictureService.uploadPictureByBatch(pictureUploadByBatchRequest, loginUser);
//
//        log.info("管理员 {} 批量上传图片，成功上传 {} 张", loginUser.getId(), uploadCount);
//
//        return ResultUtils.success(uploadCount);
//    }
//
//    /**
//     * 以图搜图 - 改良版本
//     */
//    @PostMapping("/search/picture")
//    public BaseResponse<List<ImageSearchResult>> searchPictureByPicture(
//            @RequestBody SearchPictureByPictureRequest searchPictureByPictureRequest) {
//
//        // 使用Optional优化参数校验和处理
//        Long pictureId = Optional.ofNullable(searchPictureByPictureRequest)
//                .map(SearchPictureByPictureRequest::getPictureId)
//                .filter(id -> id > 0)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "图片ID无效"));
//
//        Picture picture = Optional.ofNullable(pictureService.getById(pictureId))
//                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND_ERROR, "图片不存在"));
//
//        List<ImageSearchResult> resultList = ImageSearchApiFacade.searchImage(picture.getUrl());
//
//        // 使用Stream过滤和排序结果
//        List<ImageSearchResult> filteredResults = Optional.ofNullable(resultList)
//                .orElse(Collections.emptyList())
//                .stream()
//                .filter(Objects::nonNull)
//                .filter(result -> StrUtil.isNotBlank(result.getUrl()))
//                .sorted((r1, r2) -> Double.compare(r2.getScore(), r1.getScore())) // 按相似度降序
//                .limit(MAX_SEARCH_RESULT_SIZE) // 限制返回数量
//                .collect(Collectors.toList());
//
//        log.info("以图搜图完成，图片ID: {}, 找到 {} 个相似结果", pictureId, filteredResults.size());
//
//        return ResultUtils.success(filteredResults);
//    }
//
//    /**
//     * 按照颜色搜索 - 改良版本
//     */
//    @PostMapping("/search/color")
//    @SaSpaceCheckPermission(value = SpaceUserPermissionConstant.PICTURE_VIEW)
//    public BaseResponse<List<PictureVO>> searchPictureByColor(
//            @RequestBody SearchPictureByColorRequest searchPictureByColorRequest,
//            HttpServletRequest request) {
//
//        // 使用Optional优化参数校验
//        String picColor = Optional.ofNullable(searchPictureByColorRequest)
//                .map(SearchPictureByColorRequest::getPicColor)
//                .filter(StrUtil::isNotBlank)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "颜色参数不能为空"));
//
//        Long spaceId = Optional.ofNullable(searchPictureByColorRequest)
//                .map(SearchPictureByColorRequest::getSpaceId)
//                .orElse(null);
//
//        User loginUser = userService.getLoginUser(request);
//        List<PictureVO> pictureVOList = pictureService.searchPictureByColor(spaceId, picColor, loginUser);
//
//        // 使用Stream优化结果处理
//        List<PictureVO> filteredResults = Optional.ofNullable(pictureVOList)
//                .orElse(Collections.emptyList())
//                .stream()
//                .filter(Objects::nonNull)
//                .limit(MAX_COLOR_SEARCH_SIZE) // 限制返回数量
//                .collect(Collectors.toList());
//
//        log.info("用户 {} 按颜色搜索图片，颜色: {}, 空间ID: {}, 找到 {} 个结果",
//                loginUser.getId(), picColor, spaceId, filteredResults.size());
//
//        return ResultUtils.success(filteredResults);
//    }
//
//    /**
//     * 编辑图片（给用户使用）- 改良版本
//     */
//    @PostMapping("/edit")
//    @SaSpaceCheckPermission(value = SpaceUserPermissionConstant.PICTURE_EDIT)
//    public BaseResponse<Boolean> editPicture(@RequestBody PictureEditRequest pictureEditRequest,
//                                           HttpServletRequest request) {
//
//        // 使用Optional优化参数校验
//        Long pictureId = Optional.ofNullable(pictureEditRequest)
//                .map(PictureEditRequest::getId)
//                .filter(id -> id > 0)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "图片ID无效"));
//
//        User loginUser = userService.getLoginUser(request);
//        pictureService.editPicture(pictureEditRequest, loginUser);
//
//        log.info("用户 {} 编辑图片: {}", loginUser.getId(), pictureId);
//
//        return ResultUtils.success(true);
//    }
//
//    /**
//     * 批量编辑图片 - 改良版本
//     */
//    @PostMapping("/edit/batch")
//    @SaSpaceCheckPermission(value = SpaceUserPermissionConstant.PICTURE_EDIT)
//    public BaseResponse<Boolean> editPictureByBatch(@RequestBody PictureEditByBatchRequest pictureEditByBatchRequest,
//                                                  HttpServletRequest request) {
//
//        // 使用Optional优化参数校验
//        Optional.ofNullable(pictureEditByBatchRequest)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "批量编辑请求不能为空"));
//
//        User loginUser = userService.getLoginUser(request);
//        pictureService.editPictureByBatch(pictureEditByBatchRequest, loginUser);
//
//        log.info("用户 {} 批量编辑图片", loginUser.getId());
//
//        return ResultUtils.success(true);
//    }
//
//    /**
//     * 创建 AI 扩图任务 - 改良版本
//     */
//    @PostMapping("/out_painting/create_task")
//    @SaSpaceCheckPermission(value = SpaceUserPermissionConstant.PICTURE_EDIT)
//    public BaseResponse<CreateOutPaintingTaskResponse> createPictureOutPaintingTask(
//            @RequestBody CreatePictureOutPaintingTaskRequest createPictureOutPaintingTaskRequest,
//            HttpServletRequest request) {
//
//        // 使用Optional优化参数校验
//        Long pictureId = Optional.ofNullable(createPictureOutPaintingTaskRequest)
//                .map(CreatePictureOutPaintingTaskRequest::getPictureId)
//                .filter(id -> id > 0)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "图片ID无效"));
//
//        User loginUser = userService.getLoginUser(request);
//        CreateOutPaintingTaskResponse response = pictureService.createPictureOutPaintingTask(
//                createPictureOutPaintingTaskRequest, loginUser);
//
//        log.info("用户 {} 创建AI扩图任务，图片ID: {}, 任务ID: {}",
//                loginUser.getId(), pictureId, response.getTaskId());
//
//        return ResultUtils.success(response);
//    }
//
//    /**
//     * 查询 AI 扩图任务 - 改良版本
//     */
//    @GetMapping("/out_painting/get_task")
//    public BaseResponse<GetOutPaintingTaskResponse> getPictureOutPaintingTask(String taskId) {
//
//        // 使用Optional优化参数校验
//        String validTaskId = Optional.ofNullable(taskId)
//                .filter(StrUtil::isNotBlank)
//                .orElseThrow(() -> new BusinessException(ErrorCode.PARAMS_ERROR, "任务ID不能为空"));
//
//        GetOutPaintingTaskResponse task = aliYunAiApi.getOutPaintingTask(validTaskId);
//
//        log.info("查询AI扩图任务: {}, 状态: {}", validTaskId, task.getStatus());
//
//        return ResultUtils.success(task);
//    }
//
//    /**
//     * 获取用户图片统计信息 - 新增功能，使用Stream优化
//     */
//    @GetMapping("/stats/user")
//    public BaseResponse<Map<String, Object>> getUserPictureStats(HttpServletRequest request) {
//
//        User loginUser = userService.getLoginUser(request);
//
//        // 使用Stream构建统计信息
//        Map<String, Object> stats = Stream.of(
//                Map.entry("totalCount", pictureService.countByUserId(loginUser.getId())),
//                Map.entry("publicCount", pictureService.countByUserIdAndSpaceId(loginUser.getId(), null)),
//                Map.entry("privateCount", pictureService.countByUserIdAndNotNullSpaceId(loginUser.getId()))
//        ).collect(Collectors.toMap(
//                Map.Entry::getKey,
//                Map.Entry::getValue
//        ));
//
//        return ResultUtils.success(stats);
//    }
//
//    /**
//     * 获取热门标签 - 新增功能，使用Stream优化
//     */
//    @GetMapping("/tags/popular")
//    public BaseResponse<List<Map<String, Object>>> getPopularTags() {
//
//        // 使用缓存键生成热门标签数据
//        String cacheKey = "popular_tags";
//        String cachedResult = LOCAL_CACHE.getIfPresent(cacheKey);
//
//        if (StrUtil.isNotBlank(cachedResult)) {
//            List<Map<String, Object>> cachedTags = JSONUtil.toList(cachedResult, Map.class);
//            return ResultUtils.success(cachedTags);
//        }
//
//        // TODO: 实际应该从数据库统计，这里使用固定权重作为示例
//        Map<String, Integer> tagWeights = Stream.of(
//                Map.entry("热门", 950), Map.entry("搞笑", 800), Map.entry("生活", 750),
//                Map.entry("高清", 700), Map.entry("艺术", 650), Map.entry("校园", 600),
//                Map.entry("背景", 550), Map.entry("简历", 500), Map.entry("创意", 450),
//                Map.entry("科技", 400)
//        ).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
//
//        List<Map<String, Object>> popularTags = tagWeights.entrySet().stream()
//                .map(entry -> {
//                    Map<String, Object> tagInfo = new HashMap<>();
//                    tagInfo.put("name", entry.getKey());
//                    tagInfo.put("count", entry.getValue());
//                    return tagInfo;
//                })
//                .sorted((t1, t2) -> Integer.compare((Integer) t2.get("count"), (Integer) t1.get("count")))
//                .limit(10)
//                .collect(Collectors.toList());
//
//        // 缓存结果
//        LOCAL_CACHE.put(cacheKey, JSONUtil.toJsonStr(popularTags));
//
//        return ResultUtils.success(popularTags);
//    }
//
//    /**
//     * 缓存统计信息 - 新增功能
//     */
//    @GetMapping("/cache/stats")
//    @AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
//    public BaseResponse<Map<String, Object>> getCacheStats() {
//
//        // 使用Stream构建缓存统计信息
//        Map<String, Object> cacheStats = Stream.of(
//                Map.entry("hitCount", LOCAL_CACHE.stats().hitCount()),
//                Map.entry("missCount", LOCAL_CACHE.stats().missCount()),
//                Map.entry("hitRate", LOCAL_CACHE.stats().hitRate()),
//                Map.entry("evictionCount", LOCAL_CACHE.stats().evictionCount()),
//                Map.entry("size", LOCAL_CACHE.estimatedSize())
//        ).collect(Collectors.toMap(
//                Map.Entry::getKey,
//                Map.Entry::getValue
//        ));
//
//        return ResultUtils.success(cacheStats);
//    }
//}
